VLISP 10 . 3

3-Sep-78	[JER]
	Le PRETTY.PRINT a ete transforme pour pourvoir editer
	les fonctions LIST NCONS MCONS et CONS en notation [ ... ].
	cf: la note du 29-Aout-78 [PAT].
	Ya 2 images memoires sur SYS:	VPRETTY ET VINDEX donc
	.R VPRETTY joue un Pretty-Cross compile
	.R VINDEX  joue un INDEX compile.

2-Sep-78	[JER]
	HOURRA. Les CONS ne testent plus la fin de la liste
	libre. C'est trappe au niveau du "ill ref memory".
	On gagne pas vraiment beaucoup de temps mais de la
	place en particulier pour le compilateur qui macro-genere
	tous les CONS. Et pis ca fait tres riche de ne pas tester
	la fin des listes libres comme si yen avait toujours ...

	La fonction IMPLODE a ete ameliore : si son argument
	est une chaine, elle utilise ls caracteres de cette chaine
	ex : (IMPLODE (CONCAT "[" "A B . C" "]")) ->  (MCONS A B C)

	Les erreurs lectures sont plus causantes :
	ya des numeros d'erreur (he oui!).
	Le message est donc maintenant :
	   ** READ error : <n>   avec <n> :
	1:	une S-expr commence par un .
	2:	 "   "        "     par une ) 
	3:       "   "        "     par un ]
	4:      ya un . au plein milieu d'une liste
 	5:	ya qchose du type ( xx yy . zz ]
	6:	un ] sans [ correspondant
	7:	une ) sans ( correspondante
	8:	y pas assez de caracteres pour IMPLODE
	9:	on a donne du n'importe quoi a IMPLODE

1-Sep-78	[JER]
	2 nouvelles fonctions systemes (pour changer un peu).
	- (PATCH adress valeur) permet de modifier soi-meme
	                        le HIGH-SEG de VLISP.

	- (TMPCOR <nom>) lit un fichier TMPCOR de nom specifie.
	  Ce nouveau truc sert a SYS:VLISP.INI pour charger -APRES-
	  votre VLISP.INI, le dernier fichier .VLI qui a ete
	  utilise par l'editeur.

	En resume L'INITIALISATION  de VLISP s'opere comme suit :

	1) lecture sur la partition de l'utilisateur du fichier
	   CONFIG.INI (le 1er argument de cette fonction doit etre
	   de preference  '(SYS (VLISP . INI)) pour faire la suite.
	2) lecture sur la partition systeme su fichier VLISP.INI.
	   Ce fichier imprime ensuite : la version de l'interprete,
	   la date, l'heure et votre PPN; puis edite :
		SYS:VLISP.INI loaded.
	3) lecture (s'il existe) du fichier VLISP.INI sur VOTRE
	   partition. Le chargemnt de ce fichier se fait en silence
	   (i.e. sans rien imprimer) mais ca utilise la fonction
	   INPUT (i.e. vous pouvez mettre des appels de chargement
	   de file LIBRARY la-dedans). Apres cette lecture ca imprime :
		DSK:VLISP.INI loaded.
	4) puis si le dernier fichier utilise sous ETV a pour
	   extension .VLI, ce fichier est lu de la meme maniere
	   qu'au 3). Apres cette lecture ca imprime :
		DSK:file.VLI loaded.
	5) et apres tout ca, on ecoute la TTY...

	Toutes ces belles choses sont executees par le
	dernier PROGN du fichier SYS:VLISP.INI
	
29-Aout-78	[PAT]
	- La macro d'entree [ ... ] a ete generalisee un tant soit peu.
	  En voici la substance:
	  [x1 x2 ... xn] donne comme d'habitude (LIST x1 x2 ... xn).
	  [x]		 donne (NCONS x), pretendument plus rapide.
	  [x1 x2 ... xn . y]
	    		 donne (MCONS x1 x2 ... xn y).
	  [x . y]	 donne (CONS x y).
	  L'idee de cette generalisation est que:
	  	Il y a des listes pointees QUOTEES, ex. '(A B . C).
		Il y a donc aussi des listes pointees EVALUABLES,
						    ex.  [A B . C].

	  VLISP, encore gagnant, retablit une symetrie que les LISPs
	  anterieurs avaient laissee bien compromise.

27-Aout-78	[JER]
	- Toutes les fonctions sur P-listes ramenent toujours NIL si leurs
	premier argument est un nombre ou une chaine.
	- Nouvelle fonction ETRACE pour faciliter les TRACE et les STEP
	(ETRACE <s>) == (PROGN (STATUS 1 3) (EPROGN <s>) (STATUS 2 3))
	- la fonction DMC supporte une chaine en 1er argument.
	- la fonction (STATUS 39) est debuggee ...

26-Aout-78	[JER]
	- Nouvelles fonctions systeme :
	SHOWIT FILOP
	- Nouvelles fonctions sur les nombres :
	EQN NEQN = # > >= < <= FIXP FLOATP
	Pour la documentation sur ces dernieres fonctions,
	voir le chapitre du manuel qui cause des nombres :
		DSKM:NUMBER.MAN[LIS,JER]
	- Il existe maintenant un fichier VLISP.INI sur le disque
	systeme. Il est possible de le lire a la place du VLISP.INI
	qui se trouve sur votre partition en changeant sur votre
	fichier CONFIG.INI le 1er argument de la fonction CONFIGURATION
	de la maniere suivante :
	   a la place de '(DSK (VLISP . INI)) == '(SYS (VLISP . INI))

	En fin de lecture du SYS:VLISP.INI, une tentative de lecture
	du fichier VLISP.INI est faite ce qui permet d'avoir son
	propre fichier initial sur sa partition disque.

24-Aout-78	[JER]
	Nouvelles fonctions systemes :
	CALLI GETPPN PJOB SWITCH LIGHTS GETTAB RUNTIME DAYTIME.
	L'entree des nbs avec une base puissance de 2 a ete
	refaite en utilisant des decalages dans le HORNER.

18-Aout-78	[JER]
	Le nouveau super-hack POUR.
	Il existe une nouvelle fonction POUR qui possede
	la definition suivante :
	   (DF POUR (L) 
		(IF (EQ (CAR L) 'EVAL) 
		  (EPROGN (CDR L))
		  () ))
	Elle ne fait donc qu'evaluer le reste des args si le
	1er est (justement) EVAL.
	ex : (POUR EVAL (PRINT "Le trait POUR est present"))
        ->   "Le trait POUR est present")
        ?    (POUR ALPHONSE (GLUCKP "Fonce Alphonse"))
	->   NIL

	-------- [PAT] ------------------------------------------------
	| En effet ALPHONSE, absent, n'a donc aucune raison 
	| d'evaluer l'appel de GLUCKP.
	| Mais si j'ecris un programme avalant des s-expressions,
	| et que dans ma boucle de lecture, je place quelque chose comme
	|      (SELECTQ (CAR lu)
	| 	...
	|	(POUR (IF (EQ (CADR lu) 'ALPHONSE) (EPROGN (CDDR lu))))
	|	...)
	| Tout ce qui suit ALPHONSE dans le truc lu sera eprogne.
	| Mais si je lis une s-expression POUR telle que, par exemple:
	|            (POUR PRETTY ...)
	| il n'en sera tenu nul compte. En revanche, PRETTY similairement
	| preparee au trait-POUR dans sa propre boucle de lecture, ne
	| manquera pas d'y reagir. C'est dans l'alterite du sujet que
	| le POUR s'oblitere.
	|----------------------------------------------------------------

	Cette fonction permet de communiquer certaines 
	S-expr a certains programmes sans gener les autres.
	Les programmes trappants sont d'ordinaire les utilitaires
	traitant des fichiers.

	Par exemple le PRETTY-PRINT traite dans la boucle de
	lecture du fichier d'entree les "POUR PRETTY" de la
	maniere suivante :

	... (SETQ lu (READ))
	    (COND ((ATOM lu) (PRIN1 lu))
		  ((AND (EQ (CAR lu) 'POUR) (EQ (CADR lu) 'PRETTY))
			(EPROGN (CDDR lu)))
		  ...

18-Aout-78	[JER]
	De nouvelles fonctions : APPLYN PROG1 PROG2 EXCH OUTBUF

17-Aout-78	[JER]
	L'erreur ** arithmetic exception apparait desormais
	en cas de debordement d'entier ou de flottant ou en
	cas de division par 0.
	Un second chapitre du manuel est disponible :
		DSKB:NUMBER.DOC[LIS,JER]

16-Aout-78	[PAT]
	Une nouvelle fonction tres sophistiquee : LIT .
	(P. GREU)
	Elle se prononce (car c'est une SUBR a 3 arguments)
		
	(LIT <une-liste-L> <une-chose-E> <une-fonc-F>)

	Si L = NIL ramene E
	Sinon  L = (X1 X2 ... XN)
 	On ramene alors	
		(F X1 (F X2 ... (F XN E) ... ))

15-Aout-78	[JER]
	Le traitement des co-post-recs a l'air de correctement
	fonctionner ... enfin l'HISTOIRE jugera.
	Le nouveau manuel VLISP 10 . 3 est en cours de realisation
	les chapitres termines seront annonces.
	Ils sont tous nommes :   DSKM:xxxxxx.DOC[LIS,JER]
	Le 1er termine est PRETTY.DOC.

15-Aout-78	[PAT]
	Les DE, DF, DM, ... peuvent desormais etre ecrites en
	"call-form" i.e. "ressembler" a leurs appels.
	Forme generale:

		(Dx (le-nom . la-liste-d'agruments) . le-corps)

	Exemples:

		(DE (FOO X Y) ... ) pour (DE FOO (X Y) ...)
		(DF (FOO . X) ... ) pour (DE FOO X ... )
	
	Les anciennes formes de definition sont evidemment
	toujours valides.
	
15-Aout-78	[PAT]
	Nouvelle fonction: la SUBR SUBLIS bien connue.
	Elle utilise ASSQ.

14-Aout-78	[JER]
	Le depart a chaud fonctionne enfin. Il permet donc
	de garder des images de l'interprete entier avec
	des tas de fichiers compiles dedans ....
	Ex: je veux creer une image memoire du
	    PRETTY-PRINT compile :
	1) on compile sur disque.
	   .R VLISP
	   ....
	   (COMPILEF PRETTY T)  
	2) on charge avec un LISP frais 
	   (pour gagner la place du compilo).
	   .R VLISP
	   ...
	   (LAPF PRETTY)  ; on charge ;
	   ...
	   (LAPEND)       ; on recupere la place du LAP ;
	  puis on interrompt avec ↑C et on sauve avec la commande :
	.NSAVE PRETTY 50k
	pretty saved
	.RUN PRETTY	  ; pour executer l'image ainsi fabriquee.

	Ca marche bien mais le fichier executable resultant
	d'extension .EXE est tujours tres gros. Il faut donc 
	calculer AU PLUS JUSTE la configuration initiale
	du fichier dont on veut faire l'image....

13-Aout-78	[PAT]
	Ya un nouvel INDEXEUR :  il est sur DSK:INDEX.VLI[LIS,PAT]
	Il est normalement AUTOLOAD et il s'appelle au moyen de :
		(INDEXF <file>) ou (INDEFILE <filout> <filin>)

11-Aout-78	[JER]
	Ya un CROSS REFERENCE possible dans le PRETTY.PRINT
	Ca s'appelle :
	(CROSSF nom du fichier) ou (CROSSFILE filout filin)

5-Aout-78	[JER]
	Une nouvelle organisation de la pile (en particulier
	un nouveau format des LAMBDA-FRAME construits par
	EVAL, a ete concu et implemente pour pouvoir
	traiter correctement les appels de fonctions
	co-post-recursives. Ce type d'appel est correctement traite
	a partir de la version VLISP 10.3-15.

31-Jul-78	[JER]
	Nouvelle fonction VERSION qui ramene le numero de
	la version de l'interprete (cette fonction est utilisee
	par le chargeur et le compilateur pour s'assurer que
	le code genere correspond bien aux possibilites actuelles
	du compilateur.).
	Le depart a chaud a ete implemente il  permet
	de se creer des images prives de l'interprete dans
	lequel ont ete charges des fichier compiles.

28-Jul-78	[JER]
	Rajoute le IT feature.  from [PAT]
	Rajoute la fonction ALIAS.

24-Jun-78	[JER]
	Petit nettoyage : rajout des fonctions C....R.
	Correction du BUG dans les conversions des PPNs.

6-Jun-78	[JER]
	L'interprete a ete ameliore en ce sens qu'a l'appel
	des EXPRs, il n'y a plus d'appel a EVLIS. Les appels
	tail-recursifs sont toujours correctement traites.

28-mar-78	[JER]
	Un ensemble de fonctions permettant de sortir
	directement sur les DACs est en cours de mise-au-
	point. Toutes les suggestions sont les bienvenues.

22-mar-78	[JER]
	Un nouvel ensemble de fonctions permettent de
	travailler sur les ecrans en controlant les editions.
	Voir les fonctions PPIOT UPGIOT et CALLI.

1-mar-78	[JER]
	Certaines erreurs LISP ne snt plus fatales car le
	systeme appelle aautomatiquement des fonctions
	standards d'ereurs, qui sont redefinissables a
	volonte (cf : ERROR.UBV ERROR.UDFE ERROR.UDFA)

17-fev-78	[JER]
	Une nouvelle version du systeme VLISP 10 . 3
	est en cours d'ecriture a l'IRCAM. Toutes les
	nouveautes par rapport a l'ancienne version 
	VLISP 10 . 2 ainsi que son mode d'utilisation
	seront decrites au fur et a mesure dans ce
	fichier, en attendant la brochure definitive.
Nouvelles fonctions standards (par ordre alphabetique) :
	ces fonctions n'apparaissent dans aucunes des documentations
	actuelles de VLISP-10.

********
	C....R
	CYCLE
	DMC
	DO
	IMPLODE
	IRCAMP
	LIT
	LOGAND
	LOGOR
	LOGSHIFT
	LOGXOR
	PRINTLENGTH
	PRINTLEVEL
	PSTACK
	RPLACB
	SELF
 	SUBLIS
********

(C....R) [SUBRs a 1 argument]
	selecteurs a 4 niveaux : ex CADDAR, CDDDDR ...

(CYCLE)   [SUBR a 0 argument]
	permet de recommencer une boucle DO (voir cette fonction)
	a l'endroit de modification puis test des variables
	de controle (i.e. en fin de corps de DO).

(DMC caractere larg  ... corps ...)   [FSUBR]
	permet de definir (ou de redefinir) un macro-caractere.
	Cette fonction est equivalente a l'appel :
	(STATUS 18 'caractere (MCONS 'LAMBDA larg ... corps ...)
	et est donc plus aisee a utiliser.
	ex: (DMC /⊂ () ['PRETTY (READ)])
	Il est maintenant possible de PRETTY-PRINTER ce type
	de fonction au moyen de la fonction standard PRETTY
	ex: (PRETTY /⊂)
	->  (DMC /⊂ () ['PRETTY (READ)])

(DO ((var1 init1 rep1) ... (varN initN repN))
    ( pred e1 ... eN)
      corps du DO     )
	C'est le DO MACLISP generalise. Voir MOON 

(IMPLODE l)   [SUBR a 1 argument]
	La liste l est une liste de caracteres (atome litteraux
	mono-caractere, nombres entiers ou chaines de 1 caractere).
	IMPLODE (parfois appellee READLIST) va creer un objet
	LISP dont la representation externe est cette liste de
	caracteres. C'est donc une sorte de GENSYM ou de PACK.
	Cette fonction a l'enorme avantage d'utiliser le vrai
	fonction READ ce qui permet des choses du genre :
	 (IMPLODE '(A B C 4 "z" Q))    -> ABC4zQ
	 (IMPLODE '( 1 2 4 /. 5 6 ))   -> 124.56
	 (IMPLODE '( /( A /. B /) ))   -> (A . B)
	 (IMPLODE '( /' /( A B C /) )) -> '(A B C)
	Cette fonction permet donc de creer n'importe quel
	objet LISP (et non pas que des atomes litteraux).
	 Le message IMPLODE error, apparait en lieu et place
	de l'erreur READ error.

(IRCAMP)	[SUBR a 0 argument]
	est un predicat qui est vrai si l'interprete se trouve
	a l'IRCAM (i.e. si les terminaux sont des DATA MEDIAs)

(LIT l e f)	[SUBR a 3 agruments]
	avec
	l = (X1 X2 ... XN)
	e = quelque chose
	f = une fonction a 2 agruments

	Ramene E si l = NIL
	Ramene (F X1 (F X2 ... (F XN E) ... ))  sinon.

	LIT permet d'ecrire des definitions tres elegantes
	et concises.
	Exemples 1:
		(APPEND X Y)  =  (LIT X Y 'CONS)
		(MAPCAR L F)  =  (LIT L NIL (LAMBDA (X Y) (CONS (F X) Y)))
	Exemples 2:
		(POWERSET '(A B C)) 
			-> ((A B C) (A B) (A C) (A) (B C) (B) (C) ())
		avec
		(DE POWERSET (L) (LIT L [NIL] 'FOO))
		(DE FOO (A B) (LIT B B 'BAR))
		(DE BAR (C D) (CONS (CONS A C) D))

		(PROCAR '((A B) (C D E) (F G))
			-> ((A C F) (A C G) (A D F) ... (B E G))
		avec
		(DE PROCAR (L) (LIT L [NIL] 'FOO)
		(DE FOO (A B) (LIT A NIL 'BAR))
		(DE BAR (C D) (LIT B D 'HACK))
		(DE HACK (E F) (CONS (CONS C E) F))

(LOGAND n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de ET logique entre les deux operandes
	qui doivent etre de type entier.
	(LOGAND n1 n2) et equivalent a l'ancienne ecrirture :
	(BOOLE 6 n1 n2)

(LOGOR n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de OU logique entre les deux operandes
	qui doivent etre de type entier.
	(LOGOR n1 n2) est equivalnt a l'ancienne ecriture :
	(BOOLE 8 n1 n2)

(LOGSHIFT n1 n2)   [SUBR a 2 arguments]
	Effectue un decalage logique de la valeur n1, n2 fois.
	Si n2 est >0 un decalage gauche s'effectue, dans le cas
	contraire (n2 < 0), le decalage s'effectue a droite.

(LOGXOR n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de OU exclusif logique entre les deux
	operandes qui doivent etre de type entier.
	(LOGXOR n1 n2) et equivalent a l'ancienne ecriture :
(LOGAND n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de ET logique entre les deux operandes
	qui doivent etre de type entier.
	(LOGAND n1 n2) et equivalent a l'ancienne ecrirture :
	(BOOLE 6 n1 n2)

(LOGOR n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de OU logique entre les deux operandes
	qui doivent etre de type entier.
	(LOGOR n1 n2) est equivalnt a l'ancienne ecriture :
	(BOOLE 8 n1 n2)

(LOGSHIFT n1 n2)   [SUBR a 2 arguments]
	Effectue un decalage logique de la valeur n1, n2 fois.
	Si n2 est >0 un decalage gauche s'effectue, dans le cas
	contraire (n2 < 0), le decalage s'effectue a droite.

(LOGXOR n1 n2)   [SUBR a 2 arguments]
	Effectue l'operation de OU exclusif logique entre les deux
	operandes qui doivent etre de type entier.
	(LOGXOR n1 n2) et equivalent a l'ancienne ecriture :
	(BOOLE 9 n1 n2)

(PRINTLENGTH n)   [SUBR a 1 argument]
	Permet de specifier le nombre maximum d'elements des listes
	qui sera imprime lors des PRIN1 et PRINT. Par defaut ce nombre 
	est de 2000. Si une liste a un nombre d'elements plus eleve,
	le rste des elements ne sera pas imprime et des points
	de suspension apparaitront devant la parenthse fermante.
	Cette fonction est utilisee pour imprimer de maniere concise
	des listes parfois tres longues ...
	PRINTLENGTH ramene en valeur la longeur maximum courante.

(PRINTLEVEL n)   [SUBR a 1 argument]
	Permet de specifier la profondeur maxomum d'impression,
	i.e. le nombre maximum de parentheses ouvrantes. Comme
	PRINTLENGTH cette fonction permet d'imprimer des
	structures de maniere concise. La valeur par defaut
	de PRINTLEVEL est de 50.
	Ces deux fonctions ont en outre la vertu d'eviter
	de faire boucler les fonctions d'impression PRIN1 et PRINT
	dans le cas de listes circulaires.

(PSTACK [n])   [SUBR a 1 arg optionnel]
	Si n est fourni, c'est la nouvelle valeur a affecter au 
	pointeur de pile systeme.

(RPLACB l1 l2)   [SUBR a 2 arguments]
	est equivalente a :
	(PROGN (RPLACA L1 (CAR L2))
	       (RPLACB L1 (CDR L2)))
	I.e. que l'on remplace L1 par L2 (comme avec (SETQ L1 L2)
	mais en gardant la meme adresse physique pour le 1er doublet
	de L1. Cette fonction est principalement utilisee dans les
	MACROS qui operent des modifications physiques des fonctions.

(SELF e1 ... eN)   [SUBR a N arguments]
	Applique a la derniere lambda-expression utilisee les
	differents arguements e1 ... eN evalues. Cette fonction,
	imaginee par P. Greussay, permet de decrire des lambda-
	expressions explicites recursives, sans utiliser la
	forme archaique LABEL.
	Si cette fonction est utilisee en dehors d'une lambda
	i.e. au top-level, l'erreur suivante apparait :
		** SELF error.

	ex :
	((λ (N) (IF (=0 N) 1 (* N (SELF (1- N))))) 5) -> 120


(SUBLIS une-a-liste  une-s-expression) [SUBR a 2 agruments]
	Pour toutes les occurences dans s-expr de CAR's des
        paires pointees de la a-liste, substitue les CDR's
	correspondants.
	Ex:
	   (SUBLIS '((A . 1) (B 2 3)) '(A (B C) D B . B)))
	-> (1 ((2 3) C) D (2 3) 2 3)

	La definition en VLISP est:

   	   (DE SUBLIS (A E)
	      (LET ((E E))
		(IF (ATOM E) (LET ((X (ASSQ E A)))
				(IF X (CDR X) E))
		    (CONS (SELF (NEXTL E)) (SELF E)))))


Nouvelles fonctions systeme (par ordre alpha)

*********
	ALIAS
	DATE
	RUN
	TIME
	VERSION
*********

(ALIAS ppn) [SUBR a 1 argument]
	a le meme effet que la commande moniteur IRCAM : ALIAS.
	Si ppn=NIL, le ppn du LOGIN est utilise. Si ce n'est
	pas la version IRCAM, ALIAS ne fait rien.
	ALIAS ramene le PPN courant.

(DATE)	[SUBR a 0 argument]
	ramene l'atome representant la date du jour sous la forme:
	  jj-mmm-aa

(RUN filspec offset)   [SUBR a 2 arguments]
	sort de VLISP et joue le programme dont le nom est 
	specifie dans filespec. L'offset est rajoute a l'adresse
	de lancement du programme (en general offset = NIL).
	Attention RUN effectue un aller simple!
	ex :  	(RUN '(SYS (E . SHR))) va jouer le programme E.
		(RUN '(SYS (E . SHR)) -1) va jouer E en utilisant
				le meme fichier qu'au dernier appel de E
		(RUN '(SYS (ADV . EXE))) vous voici a l'aventure.

(TIME)	[SUBR a 0 argument]
	ramene l'heure courante sous la forme :  hh:mm:ss

(VERSION) [SUBR a 0 argument]
	ramene le numero de version de l'interprete utilise.
Fonctions standards qui utilisent la TTY

********
	DISPLAY
	PPIOT
	SETACTABLE
	TRMOP
	TYI
	TYO
	TYS
	UPGIOT
********

(DISPLAY liste nb) [SUBRN a 2 arguments]
	Cette fonction est identique a la fonction UPGIOT
	avec les arguments inverses. DISPLAY est plus pratique
	car le 1er argument n'etait jamais utilise, et est
	plus facile a se rappeller.
	ex: (DE BEEP () ; pour faire sonner son terminal ;
		(DISPLAY '(\177 7)))

(PPIOT no val)   [SUBR a 2 arguments]
	Appelle l'UUO IRCAM PPIOT avec no comme AC filed, et
	val comme AE field. Tous les renseignements utiles
	d'utilisation de cette fonction se trouvent naturellement
	dans la brochure "the IRCAM/STANDFORD Monitor".
	Cette fonction permet d'utiliser les "Page of Paper"
	des terminaux DATA-MEDIAS.
	ATTENTION : cette fonction a tendance a faire crasher le
	systeme en cas de mauvais emploi. I vaut mieux eviter.
	La principale fonction est :
	(PPIOT 0 n) qui permet de selecter la Page-of-Paper de 
	numero specifie.

(SETACTABLE ln)   [SUBR a 1agument]
	Met a jour la table d'activation des caracteres de la TTY
	en DM mode. Ramene la nouvelle table d'activation.
	ln doit etre une liste de 4 nombres qui sont codes
	conformement a la brochure (c'est d'un clair tout ca!).
	Voir SETACT UUO in IRCAM/STANDFORD monitor.
	Cette fonction doit etre utilisee pour creer des
	acros-caracteres a action immediate : les DMCI.

(TRMOP fnt index valer) [SUBR a 3 arguments]
	Cette fonction permet d'utiliser l'UUO TRMOP.
	Permet de changer les caracteristiques de la TTY sur
	laquelle on travaille (voir les brochures Monitor Calls
	et Std/Irc Monitor).
	
(TYI)   [SUBR a 0 argument]
	Ramene le code interne du caractere suivant lu sur la
	TTY sans aucune conversion et sans avoir a taper de return.
	I.e. que l'action de TYI est immediate pour 1 caractere
	frappe. Cette fonction doit etre utilisee dans tous
	les systemes un peu conversationnels ...

(TYO n)   [SUBR a 1 argument]
	Imprime sur la TTY le caractere de code interne n. L'action
	de cette fonction est immediate. Il n'est helas pas possible
	d'envoyer avec cette fonction les caracteres speciaux de 
	positionnement des DATA-MEDIAS (car ils sont filtres au niveau
	du handler TTY) pour pourvoir faire ca, i fo utiliser la
	nouvelle fonction UPGIOT.

(TYS)	[SUBR a 0 argument]
	Ramene le code interne du caractere tape ou NIL si
	aucun caractere n'a ete tape. Ca rentre tout de suite.

(UPGIOT f l)   [SUBR a 2 arguments]
	Edite sur la TTY la liste de codes internes l avec les flags l.
	C'est du bon systeme ... Pour plus ample renseignements voir
	brochure "The IRCAM/STANDFORD Monitor" par B. Harvey &
	M. Frost qui decrit l'UUO UPGIOT. Cette UUO permet d'envoyer
	sur les DATA-MEDIAs des caracteres de positionnement ...

	Il est preferable d'utiliser dorenavant la fonction
	DISPLAY en lieu et place de UPGIOT.

	ex : Cette fonction ecrit sur la Xieme ligne et a la Yeme
	colonne la chaine de caracteres S.

	(DE OUTXYS ( X ;lig; Y ;col; S ;chaine;)
	   (UPGIOT ()
	      (APPEND [\177 \14 (LOGXOR \140 Y) (LOGXOR \140 X)]
		      (MAPCAR (MAKLIST S) 'CASCII))))

	(OUTXYS 2 30 "Message a editer sur la 3eme WHO LINE...")

	De nombreux exemples d'utilisation sont ecrits dans le
	fichier :   TTY.VLI[LIS,JER]
	Vous y trouverez en particulier un programme "artistique"
	en evaluant (TTYTEST) et un jeu de CONWAY en evaluant
	(CONWAY).

	2 REMARQUABLES demonstrations sont disponibles :
	- les tours de HANOI :
		HANOI.VLI[LIS,JER]
	- AZERTUIOP et son pere :
		AZER.VLI[LIS,PAT]
Fonctions qui utilisent le DAC

**********
	DACCHN	n (0 1 2 ou 4)
	DACFIL	4000 10000
	DACOUT	nb
	DACRAT	10000
	DACS	adresse val
	DACSET	-1
**********

Ya un test qui fonctionne sur DAC.VLI[LIS,JER]
L'utilisation actuelle est peu recommandee car elle bloque
le time-sharing....
Modifications

 Ya pas a priori de modifications qui obligent a corriger
de l'ancien code.

**********

	La fonction TOPLEVEL standard  stocke dans l'atome IT
	la valeur retournee par l'evaluation. Ceet atome
	fait donc office de resultat intermediaire qui peut
	etre reutilise :

	EX: (* 2 10)
	= 20
	? (* IT 3)
	= 60
	? (// IT 6)
	= 10 ...

**********

    ----- Une nouveaute PATRICK GREUSSAY -----
 Il n'est plus necessaire de quoter les lambdas-expressions
explicites dans les fonctionnelles.

ex : (MAPC L (LAMBDA (X) ... )) remplace avantageusement
     (MAPC L (QUOTE (LAMBDA (X) ... )))

**********

    La fonction LIBRARY emet les diagnostiques :
** LIBRARY error : <file>
si on essaie de lire le fichier LIBRARY <file> a l'interieur d'un 
autre fichier LIBRARY.
** READ error (in LIBRARY).
a l'occurence d'une erreur dans le READ d'un fichier LIBRARY.
**********

 Les Entrees/Sorties ont (encore) subies beaucoup de transformations
en particulier pour ce qui est du terminal :
- de nouvelles fonctions sont disponibles TYI TYO UPGIOT PPIOT
- un renfoncement automatique, sur entree TTY, a lieu
  automatiquement. On peut desormais pretty-printer tres
  facilement ses fonctions en entree (c'est tres simple a
  faire mais c'est bien utile ...)
- les diagnostiques des erreurs de lecture sont plus explicite en ce
  sens qu'on peut distinguer le manque de parenthses fermantes
  d'une erreur de . ou de [] .
- le bit 19 du RG permet d'arreter le transcodage minuscule
  majuscule a la lecture. Si (STATUS 1 19) la traduction a lieu
  et c'est le cas standard; si (STATUS 2 19) les cases ont une 
  importance. Ce nouveau trait est dorenavant utilise dans le
  PRETTY-PRINT qui restitue les cases originelles.
Recuperation des Erreurs LISP 

A L'apparition de certaines erreurs, LISP appelle desormais
des fonctions standards (qui peuvent etre redefinies). La valeur de
ces fonctions devient la valeur de la forme qui avait provoquee
l'erreur. Ce nouveau trait a ete ajoute pour permettre
l'introduction de dispositifs speciaux de traitement des
erreurs (pas vrai Harald!).

Ces fonctions ont ete introduites dans les fichiers initiaux
en particulier sur : VLISP.INI[LIS,JER]
Dans le cas ou on ne desire pas redefinir ce genre de fonctions,
LISP ecrit en plus des messages d'erreurs standards 2 nouvelles
informations :
--- last forme = "le derniere forme evaluee par EVAL"
--- last fnt   = "la derniere lambda-expresssion evaluee"

Variable undefinie : 
	a l'apparition de cette erreur, la fonction ERROR.UBV
	est appliquee avec comme argument:
	- le nom de l'atome undefini
	- le pointeur de pile courant
	- le pointeur des liens dans la pile P$BIND
	  (ce pointeur permet de recuperer la derniere lambda
	   expression utilisee).

ex :
	
(DE ERROR.UBV (ATOME PILE P$BIND)
   (PRINT "Variable undefinie : " ATOME)
   (PRINT "Je lui donne la valeur NIL")
   NIL))

Fonction undefinie dans EVAL :
	A l'apparition de cette erreur, la fonction ERROR.UDFE est
	appliquee avec comme argument :
	- la fonction undefinie
	- la forme qui etait en cours d'evaluation
	- le pointeur courant sur la pile
	- le pointeur des liens dans la pile P$BIND
	  (voir la remarque precedente)

Fonction undefinie dans APPLY :
	A l'apparition de cette erreur, la fonction ERROR.UDFA est
	appliquee avec les memes arguments que ERROR.UDFE.

;;; ex de definition des traps erreurs ;;;

(DE ERROR.UBV (ATOME PILE P$BIND)
    (PRINT "Variable undefinie : " ATOME)
    (OR (ZEROP P$BIND) ; si P$BIND = NIL yavait pas de λ en cours ;
	(PROGN
	    (PRINTLEVEL 6) ; des fois les fnts sont trop longues ;
	    (PRINTLENGTH 10) ; dito ;
	    (PRINT "La derniere λ etait : "
		; cet horrible HACK recupere dans la pile la λ ;
		(VAG (STATUS 41 (ADD1 (LOGAND P$BIND \777777)))))
	    (PRINTLEVEL 50) ; restaure les valeurs courantes ;
	    (PRINTLENGTH 2000)))
    (RESET) ; pour rentrer gentillemennt sus LISP ;)

(DE ERROR.UDFE (FNT FORME PILE P$BIND)
    ; Undefined function EVAL ;
    (ERROR.UDF "Fonction undefinie dans EVAL : "))

(DE ERROR.UDFA (FNT FORME PILE P$BIND)
    ; Undefined function APPLY ;
    (ERROR.UDF "Fonction undefinie dans APPLY : "))

(DE ERROR.UDF (MSG)
    ; Fonction generale d'erreur FUNCTION UNDEFINED ;
    (PRINT MSG FNT)
    (PRINTLEVEL 6)
    (PRINTLENGTH 10)
    (PRINT "La derniere forme etait : " FORME)
    (OR (ZEROP P$BIND)
	    (PRINT "La derniere λ etait : "
		(VAG (STATUS 41 (ADD1 (LOGAND P$BIND \777777))))))
    (PRINTLEVEL 50)
    (PRINTLENGTH 2000)
    (RESET))
Interruptions

L'interruption "ESCAPE I" a ete introduite; elle permet d'interrompre
l'execution d'un programme LISP, d'executer un autre programe LISP,
et de revenir au programme interrompu.
Cette interruption est provoquee par l'envoie d'un code special
sur la TTY : le ESCAPE-I qui se frappe : NUL puis I ou bien
NUL puis une suite de digits decimaux puis I.

A l'apparition d'une interruption de ce type, LISP lance
une fonction de nom ESCAPE.I avec pour arguments :
1 - le nombre tape entre NUL et I (i.e. le numero du ESCAPE-I)
2 - le pointeur de pile lui-meme
3 - le pointeur des BINDs dans le pile (P$BIND)
Ces arguments permettent toutes les manipulations au niveau
de la pile (en particulier les restaurations de contextes et
de pile) de la meme maniere que les erreurs LISP.
 
Cette fonction d'une facon standard imprime le libelle :
   ** ESCAPE-I : argument numerique
puis retourne au programme interrompu.

Il est tout-a-fait possible de redefinir cette fonction pour
gerer par soi meme ce type d'interruption.
Un exemle d'utilisation de cette fonction se trouve dans
le fichier  ESCAPI.VLI[LIS,JER]

Cette fonction est definie en general dans les fichiers
VLISP.INI de la maniere suivante :

(DE ESCAPE.I (numero pile p$bind unbreak lu it)
	(TERPRI)
	(PRINT "Je rentre dans un TOPLEVEL ESCAPE-I.")
	(PRINT "Pour en sortir, tape  UNBREAK      .")
	(STATUS 11 '/!)
	(SETQ unbreak)
	(UNTIL unbreak
	   (SETQ lu (READ))
	   (IF (EQ lu 'unbreak) (SETQ unbreak T)
		(SETQ it (PRINT (EVAL lu)))))
	(STATUS 11 '/?)
	(PRINT "Ca roule..."))
; Ce qui permet d'efectuer des BREAKS tres commodement ;

; Dans le meme genre d'idee ;

(DE ESCAPE.I (numero pile p$bind lu it)
	(TERPRI)
	(PRINT "Je rentre dans un TOPLEVEL ESCAPE-I.")
	(PRINT "Pour en sortir, commence une ligne par <META-ESPACE>.")
	(STATUS 11 '/!)
	(TEREAD)
	(UNTIL (EQ (PEEKCH) '/ )
	   (SETQ lu (READ))
           (SETQ it (PRINT (EVAL lu))))
	(STATUS 11 '/?)
	(PRINT "Ca roule..."))

; le fonctionnement minimum consiste en : ;

(DE ESCAPE.I (N)
   (INTERRUPT "Merci..."))

(DE TESTINT ()
   (ESCAPE INTERRUPT
      (PRINT "Interrompez-moi s.v.p.")
      (WHILE T ())

; On utilise couramment cette interruptions avec des 
  fonctions d'echappement de type ESCAPE ;


(DE ESCAPE.I () (TERMIN <valeur a retourner>))

   ; et dans une fonction : ;
   (ESCAPE termin
      (WHILE T
   	...
      ))
   ; endroit ou l'on veut recevoir une valeur et revenir
     a l'occurence d'une interruption ESCAPE.I ;
*** BUGS ***

Tous les bugs trouves a Vincennes
 sur la version 2 ont ete
corriges.

les nouveaux :

- 28 mars 78

	Un tres tres jouli BUG dans le Garbage-Collecting des
	nombres flottants provoquait l'erreur ** no room for nbs
	dans des cas inimaginables ... Le G.C. devrait fonctionner
	normalement maintenant.

- 23 mars 78

	La fonction DA ne permettait pas de declarer plus de
	2 tableaux a la fois (c'etait pas beaucoup ...). 
	Maintenant on peut. Merci Daniel.